水無瀬 優 postmaster@katsura-kotonoha.sakura.ne.jp
http://katsura-kotonoha.sakura.ne.jp/prog/code/tools/misc/sha256_cpp.shtml
| 水無瀬の部屋 > Programming > sample > tools > misc > sha256.cpp |
|---|
1: //*********************************************************
2: // プロジェクト: TOOLS::SHA256 - Secure Hash Algorithm
3: // ファイル名: sha256.cpp
4: //*********************************************************
5: #include <misc/sha256.h> //
6: #include <header/tooldbg.h> // ASSERT(),
7: #include <header/toolbase.h> //
8: #include <header/snprintf.h> // snprintf(), vsnprintf(),
9: #include <limits.h> // CHAR_BIT,
10:
11:
12: //---------------------------------------------------------
13: // テスト関数 の 宣言
14: //---------------------------------------------------------
15: DECLARE_TESTPROC( test_sha256 );
16:
17:
18: //---------------------------------------------------------
19: // 定数型マクロ の 定義
20: //---------------------------------------------------------
21: #define DBG_ALLOCNAME "SHA256_CreateAlgorithm"
22:
23: //
24: #define SHA256_HASH 8
25: #define SHA256_BLOCK 16
26: #define SHA256_WORK 64
27:
28:
29: //---------------------------------------------------------
30: // 構造体 の 宣言
31: //---------------------------------------------------------
32: typedef struct SHA256_CTX_tag
33: {
34: //
35: DWORD length; // 総書込バイト数
36: DWORD state[ 8 ]; //
37:
38: //
39: DWORD index; // バッファの最終書込バイト位置
40: DWORD buffer[ 16 ]; //
41: } SHA256_CTX;
42:
43:
44: //---------------------------------------------------------
45: // ファイルスコープ関数 の 宣言
46: //---------------------------------------------------------
47: static void SHA256_Transform( DWORD *state, const DWORD *buffer );
48: static inline DWORD ReverseEndian(DWORD x) {return (x << 24) | ((x & 0x0000ff00) << 8) | ((x & 0x00ff0000) >> 8) | (x >> 24);}
49: static bool SHA256_IsValidContext( const SHA256_CTX *context );
50:
51:
52: //*********************************************************
53: // SHA256_CreateAlgorithm
54: //*********************************************************
55: SHA256_CTX *
56: SHA256_CreateAlgorithm
57: (
58: void
59: )
60: {
61: CALLONCE_TESTPROC( test_sha256 ); // [テスト]
62:
63: SHA256_CTX *context = (SHA256_CTX *)malloc( sizeof( *context ) );
64: if ( !context )
65: return null;
66:
67: SHA256_InitData( context );
68: ASSERT( SHA256_IsValidContext( context ) );
69:
70: DBG_LOCK_ALLOCED_MEMORY( context, DBG_ALLOCNAME ); // [DBG]
71: return context;
72: }//SHA256_CreateAlgorithm
73:
74: //*********************************************************
75: // SHA256_DestroyAlgorithm
76: //*********************************************************
77: bool
78: SHA256_DestroyAlgorithm
79: (
80: SHA256_CTX *context
81: )
82: {
83: // パラメタの仮定
84: ASSERT( SHA256_IsValidContext( context ) );
85:
86: DBG_UNLOCK_ALLOCED_MEMORY( context, DBG_ALLOCNAME ); // [DBG]
87: free( context );
88:
89: return true;
90: }//SHA256_DestroyAlgorithm
91:
92: //*********************************************************
93: // SHA256_InitData
94: //*********************************************************
95: bool
96: SHA256_InitData
97: (
98: SHA256_CTX *context
99: )
100: {
101: // パラメタの仮定
102: ASSERT( IsValidPtr( context, sizeof( *context ) ) );
103:
104: context->index = 0;
105: context->length = 0;
106:
107: const DWORD state[] =
108: {
109: 0x6a09e667,
110: 0xbb67ae85,
111: 0x3c6ef372,
112: 0xa54ff53a,
113: 0x510e527f,
114: 0x9b05688c,
115: 0x1f83d9ab,
116: 0x5be0cd19,
117: };
118: memzero( context->buffer, sizeof( context->buffer ) );
119: memcpy( context->state, state, sizeof( context->state ) );
120:
121: ASSERT( SHA256_IsValidContext( context ) );
122: return true;
123: }//SHA256_InitData
124:
125: //*********************************************************
126: // SHA256_AddData
127: //*********************************************************
128: bool
129: SHA256_AddData
130: (
131: SHA256_CTX *context,
132: const void *data,
133: int length
134: )
135: {
136: // パラメタの仮定
137: ASSERT( SHA256_IsValidContext( context ) );
138: ASSERT( 0 < length );
139: ASSERT( IsValidReadPtr( data, length ) );
140:
141: const BYTE *p = (BYTE *)data;
142: while( 0 < length )
143: {
144: const DWORD use = min( ((DWORD)length), (sizeof( context->buffer ) - context->index) );
145: memcpy( ((BYTE *)context->buffer) + context->index, p, use );
146: p += use;
147: context->index += use;
148: context->length += use;
149: length -= use;
150:
151: if ( sizeof( context->buffer ) <= context->index )
152: {
153: SHA256_Transform( context->state, context->buffer );
154: context->index = 0;
155: }
156: }
157:
158: return true;
159: }//SHA256_AddData
160:
161: //*********************************************************
162: // SHA256_GetHash
163: //*********************************************************
164: bool
165: SHA256_GetHash
166: (
167: const SHA256_CTX *context,
168: void *digest,
169: int bufsize
170: )
171: {
172: // パラメタの仮定
173: ASSERT( SHA256_IsValidContext( context ) );
174: ASSERT( 0 < bufsize );
175: ASSERT( IsValidPtr( digest, bufsize ) );
176: DESTROY_BUFFER( digest, bufsize );
177:
178: SHA256_CTX tmp_context;
179: memcpy( &tmp_context, context, sizeof( *context ) );
180: context = null;
181:
182: DWORD dwNumBits[ 2 ];
183: dwNumBits[ 0 ] = ReverseEndian( (tmp_context.length >> 29) );
184: dwNumBits[ 1 ] = ReverseEndian( (tmp_context.length << 3) );
185:
186: BYTE cOne = 0x80;
187: SHA256_AddData( &tmp_context, &cOne, 1 );
188: while( tmp_context.index != sizeof( tmp_context.buffer ) - 8 )
189: {
190: BYTE cZero = 0x00;
191: SHA256_AddData( &tmp_context, &cZero, 1 );
192: }
193:
194: SHA256_AddData( &tmp_context, dwNumBits, 8 );
195: memmove( digest, tmp_context.state, min( bufsize, sizeof( tmp_context.state ) ) );
196:
197: return true;
198: }//SHA256_GetHash
199:
200: //*********************************************************
201: // SHA256_GetHashText
202: //*********************************************************
203: bool
204: SHA256_GetHashText
205: (
206: const SHA256_CTX *context,
207: char *buffer,
208: int bufsize
209: )
210: {
211: // パラメタの仮定
212: ASSERT( SHA256_IsValidContext( context ) );
213: ASSERT( 0 < bufsize );
214: ASSERT( IsValidStringBufferPtr( buffer, bufsize ) );
215: DESTROY_TEXT_BUFFER( buffer, bufsize );
216:
217: //
218: BYTE sha256[ SHA256_HASHSIZE ];
219: VERIFY( SHA256_GetHash( context, sha256, sizeof( sha256 ) ) );
220:
221: //
222: char text[ 1+SHA256_HASHTEXTSIZE ];
223: {
224: char *p = text;
225: {for( int i = 0; i < numof( sha256 ); i += sizeof( DWORD ) )
226: {
227: {for( int j = 0; j < sizeof( DWORD ); ++j )
228: {
229: snprintf( p, numof(text) - (p - text), "%02x", sha256[ i + (sizeof( DWORD ) - j - 1) ] );
230: p = strtail( p );
231: }}
232: }}
233: }
234:
235: //
236: memcpy( buffer, text, min( bufsize, sizeof( text ) ) );
237: buffer[ min( bufsize, numof( text ) ) - 1 ] = '\0';
238:
239: return true;
240: }//SHA256_GetHashText
241:
242:
243: //******************************************************************************************************************
244: //
245: //******************************************************************************************************************
246: //
247: static inline DWORD ROTATE_LEFT(DWORD x, DWORD n) {return (x >> n) | (x << (32 - n));}
248: static inline DWORD S0(DWORD x) {return ROTATE_LEFT(x, 2) ^ ROTATE_LEFT(x, 13) ^ ROTATE_LEFT(x, 22);}
249: static inline DWORD S1(DWORD x) {return ROTATE_LEFT(x, 6) ^ ROTATE_LEFT(x, 11) ^ ROTATE_LEFT(x, 25);}
250: static inline DWORD s0(DWORD x) {return ROTATE_LEFT(x, 7) ^ ROTATE_LEFT(x, 18) ^ (x >> 3);}
251: static inline DWORD s1(DWORD x) {return ROTATE_LEFT(x, 17) ^ ROTATE_LEFT(x, 19) ^ (x >> 10);}
252: static inline DWORD Ch(DWORD x, DWORD y, DWORD z) {return (x & (y ^ z)) ^ z;}
253: static inline DWORD Maj(DWORD x, DWORD y, DWORD z) {return (x & (y | z)) | (y & z);}
254: //
255: const DWORD c_dwK[SHA256_WORK] =
256: {
257: 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
258: 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
259: 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
260: 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
261: 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
262: 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
263: 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
264: 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
265: };
266:
267:
268: //*********************************************************
269: // SHA256_IsValidContext
270: //*********************************************************
271: static
272: bool
273: SHA256_IsValidContext
274: (
275: const SHA256_CTX *context
276: )
277: {
278: VALID_TEST( context );
279: VALID_TEST( IsValidReadPtr( context, sizeof( *context ) ) );
280: VALID_TEST( (0 <= context->index) && (context->index < sizeof( context->buffer ) ) );
281:
282: return true;
283: }//SHA256_IsValidContext
284:
285: //*********************************************************
286: // SHA256_Transform
287: //*********************************************************
288: static
289: void
290: SHA256_Transform
291: (
292: DWORD *state,
293: const DWORD *buffer
294: )
295: {
296: DWORD work[ SHA256_WORK ];
297: {for( int i = 0; i < SHA256_BLOCK; ++i )
298: {
299: work[ i ] = ReverseEndian( buffer[ i ] );
300: }}
301: {for( int i = SHA256_BLOCK; i < SHA256_WORK; ++i )
302: {
303: work[ i ] = s1( work[ i - 2 ] ) + work[ i - 7 ] + s0( work[ i - 15 ] ) + work[ i - 16 ];
304: }}
305:
306: DWORD Hash[ SHA256_WORK + SHA256_HASH ];
307: DWORD *pHash = &Hash[ SHA256_WORK ];
308: memcpy( pHash, state, SHA256_HASH * sizeof( DWORD ) );
309:
310: {for( int i = 0; i < SHA256_WORK; ++i )
311: {
312: pHash--;
313: DWORD dwT1 = pHash[8] + S1(pHash[5]) + Ch(pHash[5], pHash[6], pHash[7]) + c_dwK[i] + work[i];
314: DWORD dwT2 = S0(pHash[1]) + Maj(pHash[1], pHash[2], pHash[3]);
315: pHash[0] = dwT1 + dwT2;
316: pHash[4] += dwT1;
317: }}
318:
319: {for( int i = 0; i < SHA256_HASH; ++i )
320: {
321: state[ i ] += pHash[ i ];
322: }}
323: }//SHA256_Transform
324:
325:
326: //******************************************************************************************************************
327: // TEST
328: //******************************************************************************************************************
329:
330:
331: #ifdef _DEBUG // デバッグ時のみ
332:
333:
334: //*********************************************************
335: // test_sha256
336: //*********************************************************
337: DEFINE_TESTPROC( test_sha256 )
338: {
339: //---------------------------------------------------------
340: // 定数 の テスト
341: //---------------------------------------------------------
342:
343: //---------------------------------------------------------
344: // ファイルスコープ関数 の テスト
345: //---------------------------------------------------------
346:
347: //---------------------------------------------------------
348: // 公開関数 の テスト
349: //---------------------------------------------------------
350:
351: static const BYTE testcase[] =
352: {
353: 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
354: 0x2e, 0xd1, 0x73, 0x47, 0x93, 0xbb, 0x71, 0x23, 0x54, 0x0f, 0x9a, 0x5b, 0xc3, 0xa1, 0xb4, 0x39, 0x14, 0x24, 0x3f, 0xad, 0xf8, 0x80, 0x69, 0xb8, 0xfa, 0x1c, 0x8d, 0x41, 0xef, 0xdf, 0xfa, 0xbd,
355: 0x41, 0xc1, 0x5c, 0x29, 0x2d, 0xe5, 0x4f, 0xf7, 0x07, 0x71, 0x9e, 0xd9, 0xb1, 0x79, 0x35, 0x0a, 0xc4, 0xe1, 0xb0, 0xfa, 0xa1, 0x7c, 0x0f, 0xdd, 0xaf, 0x58, 0x75, 0x7b, 0x22, 0x21, 0xfa, 0xcc,
356: 0x67, 0xbc, 0x6d, 0x51, 0x65, 0x08, 0xbb, 0x60, 0x8a, 0x97, 0xf4, 0x1a, 0x5e, 0xcd, 0x5a, 0xa1, 0x9d, 0x82, 0x99, 0x3b, 0xe3, 0x6e, 0xdd, 0x10, 0x66, 0xf9, 0xf4, 0x13, 0xc5, 0xca, 0x9f, 0x17,
357: 0x0b, 0xa5, 0xbb, 0x1c, 0xb5, 0xe5, 0xc4, 0x9b, 0xa1, 0xe2, 0xf1, 0xb3, 0x7a, 0x70, 0x41, 0xf4, 0xed, 0xc8, 0x1f, 0x9e, 0xa5, 0x2f, 0xf5, 0x85, 0xb4, 0x8a, 0xd8, 0x22, 0x59, 0xa0, 0xc3, 0x53,
358: 0xe6, 0x85, 0xbd, 0xa2, 0xdd, 0x93, 0x2a, 0xb7, 0x39, 0x1b, 0x15, 0xb6, 0x4d, 0x66, 0xbd, 0x35, 0xb6, 0xb7, 0x1a, 0x9f, 0x42, 0xf0, 0xc6, 0x9c, 0x3c, 0x81, 0x38, 0xde, 0x6f, 0xa5, 0x2c, 0x3a,
359: 0x7a, 0xc8, 0x96, 0x12, 0x0a, 0xba, 0x3b, 0x81, 0x2e, 0x3a, 0xd0, 0x91, 0xcf, 0x68, 0x8f, 0x7b, 0xf5, 0xfc, 0x77, 0x14, 0xe9, 0x3c, 0xac, 0x2b, 0xda, 0xa2, 0x0a, 0x6c, 0x8c, 0xea, 0xa9, 0x06,
360: 0xf9, 0x86, 0x76, 0x8e, 0x18, 0xb6, 0xb8, 0xcc, 0x6a, 0xc6, 0x3a, 0x19, 0x12, 0x37, 0xa0, 0x76, 0xe4, 0xd4, 0xf0, 0x82, 0xe7, 0x10, 0x87, 0xa1, 0xcf, 0xd6, 0x92, 0x95, 0xc8, 0x5c, 0x16, 0x5e,
361: 0xb8, 0x44, 0xd6, 0x26, 0x23, 0xc6, 0x5c, 0x58, 0xe0, 0xcf, 0x6a, 0x42, 0x08, 0x8a, 0xd5, 0xf0, 0x79, 0x07, 0xd7, 0x10, 0x2f, 0xd1, 0x94, 0x96, 0xcc, 0x39, 0xcc, 0xcb, 0x74, 0x5e, 0xb4, 0xef,
362: 0xc2, 0xc7, 0xd5, 0xee, 0x11, 0xc0, 0xee, 0x91, 0xf9, 0x8a, 0x3e, 0xfc, 0x87, 0x66, 0x54, 0x5d, 0x14, 0xc8, 0x48, 0x5a, 0xe0, 0x04, 0xb8, 0x3c, 0xaf, 0x2d, 0x7a, 0x4d, 0x5b, 0xa2, 0x10, 0x31,
363: 0x4f, 0x35, 0xeb, 0xbd, 0x47, 0x40, 0x51, 0xd1, 0xe8, 0x58, 0xa4, 0xe0, 0x0c, 0xa1, 0x0e, 0x36, 0x90, 0x09, 0x21, 0x64, 0xc7, 0x7b, 0xb4, 0x3e, 0x0e, 0xb2, 0xaa, 0x91, 0xb8, 0x31, 0x1e, 0x86,
364: 0xb8, 0xf2, 0xea, 0x1c, 0xae, 0x69, 0x18, 0x09, 0xbc, 0x7b, 0x33, 0xe6, 0xcc, 0x68, 0x98, 0xbd, 0xfe, 0xc7, 0x97, 0xf2, 0x14, 0xbf, 0x0e, 0xf9, 0x55, 0x7c, 0x32, 0x7e, 0x68, 0xac, 0x7b, 0xa6,
365: 0x58, 0x0b, 0xfd, 0x62, 0x64, 0xc9, 0x04, 0xa8, 0xe3, 0x04, 0x71, 0xf1, 0x72, 0x6f, 0x5b, 0x09, 0xad, 0xc7, 0x51, 0x29, 0xe3, 0x9e, 0x6d, 0x3e, 0xa8, 0x23, 0xd8, 0xad, 0x82, 0x97, 0x23, 0x8c,
366: 0xa6, 0xa3, 0xd7, 0x5d, 0xee, 0xdd, 0xe0, 0xf1, 0x6d, 0xf2, 0xa4, 0xb7, 0xa8, 0x8a, 0x68, 0x00, 0x35, 0x12, 0x85, 0x30, 0x15, 0x64, 0x60, 0x67, 0x6a, 0x1f, 0xec, 0x40, 0xa2, 0xbf, 0x77, 0x31,
367: 0x8d, 0x4c, 0xa7, 0x2e, 0xc6, 0x94, 0x97, 0xf2, 0x90, 0xd5, 0xf6, 0x76, 0x74, 0xa2, 0x56, 0x1e, 0xbd, 0xfb, 0xc8, 0xdf, 0x31, 0x32, 0x42, 0xe5, 0xeb, 0x8f, 0x27, 0x85, 0x8f, 0x27, 0x4b, 0x4d,
368: 0x91, 0x18, 0x7b, 0x4b, 0x5f, 0x8a, 0x16, 0x22, 0xb3, 0x2a, 0xf3, 0x59, 0x7d, 0xf5, 0x5b, 0xff, 0xf6, 0x77, 0x39, 0xfc, 0x2a, 0xc6, 0xe5, 0xf5, 0x0b, 0xba, 0xbd, 0x9f, 0x8d, 0x18, 0xf9, 0x21,
369: 0x51, 0x7c, 0x1d, 0xbe, 0x61, 0x4f, 0xbc, 0x47, 0x68, 0x3c, 0xbc, 0xd9, 0x2c, 0x43, 0x4e, 0x3c, 0x7a, 0x5f, 0x64, 0x73, 0x64, 0x87, 0x4d, 0x08, 0x7d, 0xb9, 0x77, 0x75, 0x24, 0x8f, 0x36, 0x84,
370: 0x96, 0x44, 0x70, 0x6c, 0x8b, 0x9d, 0xe8, 0x99, 0x5e, 0xb8, 0xa4, 0xca, 0xc5, 0xa4, 0x86, 0x35, 0x25, 0x63, 0x2b, 0x26, 0x23, 0x53, 0x59, 0xa7, 0x62, 0x99, 0xf2, 0x7a, 0x7b, 0xde, 0x65, 0x5c,
371: 0x82, 0x44, 0x78, 0x53, 0xf4, 0x44, 0x17, 0x3b, 0xe3, 0xf1, 0x33, 0x5e, 0xd0, 0xed, 0x8d, 0x10, 0x5e, 0xe9, 0xc5, 0xfa, 0x4f, 0x0f, 0xa9, 0x40, 0x36, 0x98, 0x5f, 0x07, 0x1c, 0x27, 0x5a, 0x1c,
372: 0x8a, 0x83, 0xee, 0x47, 0xb2, 0xd2, 0xf0, 0xa1, 0xc5, 0xec, 0x3b, 0x44, 0x9d, 0xb9, 0xb1, 0x6c, 0x8b, 0x04, 0x94, 0x82, 0x00, 0x12, 0x23, 0x96, 0xbd, 0xec, 0x8f, 0xe0, 0x0e, 0x1b, 0xc5, 0xe2,
373: 0x36, 0x25, 0x8c, 0x50, 0x74, 0x9f, 0xb1, 0x04, 0xa9, 0x3d, 0x08, 0x65, 0xca, 0xbb, 0x57, 0xf1, 0xef, 0x0d, 0x4d, 0xbf, 0x4f, 0xd7, 0xcb, 0x68, 0x26, 0x3c, 0x95, 0xbd, 0x3a, 0xaf, 0x6a, 0x5f,
374: 0x12, 0x3f, 0x2c, 0x49, 0x6f, 0xd7, 0xf6, 0x2d, 0x73, 0xb6, 0x97, 0x3d, 0x28, 0xc2, 0xbf, 0xfa, 0x59, 0x3b, 0xb3, 0xde, 0x72, 0x3a, 0x4c, 0x45, 0x08, 0x8d, 0x87, 0x2d, 0x07, 0xbc, 0x9c, 0xdb,
375: 0x4f, 0xfd, 0x6c, 0x85, 0x03, 0xbf, 0xa7, 0xa7, 0x44, 0xfd, 0x27, 0xc0, 0x0c, 0x4b, 0x51, 0x14, 0xb6, 0x3c, 0x62, 0xbd, 0xc2, 0x30, 0xe1, 0xb6, 0x78, 0x3c, 0xd3, 0x2c, 0xad, 0x68, 0xe1, 0xdf,
376: 0x59, 0xcb, 0x11, 0xb2, 0x4f, 0xd0, 0x58, 0x04, 0xfb, 0xce, 0xab, 0xd4, 0x74, 0xaf, 0xf5, 0x38, 0xba, 0x75, 0x45, 0xae, 0x70, 0x35, 0xda, 0x0a, 0xba, 0xd8, 0xd0, 0x4b, 0xa2, 0x37, 0xfa, 0xef,
377: 0xa1, 0x5a, 0x69, 0x81, 0xc6, 0x19, 0x69, 0x67, 0x12, 0x9d, 0xb4, 0x3a, 0xe3, 0x40, 0x2b, 0x70, 0xc6, 0x24, 0x53, 0x9e, 0x30, 0xa5, 0x67, 0xa3, 0xd3, 0xe2, 0xa4, 0x25, 0x0d, 0x5b, 0x5a, 0x85,
378: 0xa6, 0x1a, 0x8c, 0x9b, 0x8e, 0xcd, 0xac, 0x47, 0x93, 0xd7, 0x98, 0x03, 0x2b, 0xdb, 0xde, 0x43, 0x85, 0x21, 0xc6, 0x0f, 0xed, 0x9e, 0xcc, 0x6d, 0xd0, 0x42, 0x35, 0x88, 0xe4, 0x36, 0x5d, 0x17,
379: 0x7c, 0x82, 0x1f, 0x59, 0xae, 0xc5, 0x98, 0x06, 0x94, 0x26, 0xe8, 0x86, 0xdf, 0x7e, 0x52, 0x0d, 0x56, 0x4b, 0x2e, 0x7e, 0xf6, 0x5d, 0xb0, 0xd7, 0x7f, 0x50, 0x6f, 0x51, 0x61, 0xc8, 0x2f, 0x84,
380: 0x5a, 0x82, 0x2f, 0x7f, 0x88, 0x3e, 0x83, 0xd9, 0x58, 0x73, 0x4c, 0x5d, 0x99, 0x22, 0xde, 0x30, 0x30, 0x14, 0xc0, 0xa1, 0x7f, 0x39, 0xf0, 0x54, 0xa3, 0xf3, 0xc4, 0x11, 0xc7, 0x90, 0xbc, 0xf9,
381: 0xf8, 0x75, 0xdb, 0xdd, 0x13, 0xda, 0x6c, 0xdf, 0x69, 0x99, 0x43, 0x0c, 0xd7, 0x97, 0xc8, 0xf2, 0xb4, 0x8d, 0xea, 0x44, 0xaf, 0xbe, 0x54, 0xdc, 0x43, 0x10, 0x74, 0xa5, 0x4b, 0xfa, 0xbd, 0xa4,
382: 0x68, 0x18, 0x83, 0x3a, 0x33, 0xdf, 0x2e, 0xd9, 0xac, 0x83, 0x93, 0xba, 0xf2, 0x26, 0xe0, 0x09, 0x4b, 0xf5, 0xab, 0x6c, 0xfd, 0xd9, 0xe7, 0xcc, 0x47, 0x61, 0xa6, 0xd9, 0xec, 0x34, 0x8d, 0x73,
383: 0xb7, 0xa5, 0x4b, 0x19, 0x93, 0xb2, 0x24, 0xcb, 0x67, 0xc2, 0x36, 0x89, 0x5a, 0x8e, 0xf1, 0x06, 0xdd, 0x26, 0xe0, 0x88, 0x89, 0x8c, 0x11, 0xe8, 0x29, 0xdb, 0x5d, 0x18, 0x9c, 0x46, 0xa2, 0xff,
384: 0x5c, 0xb4, 0xfd, 0x13, 0x27, 0xa2, 0x27, 0x6a, 0x33, 0xf2, 0xda, 0xf2, 0x25, 0xb9, 0xa8, 0xde, 0xce, 0xee, 0x12, 0x89, 0xf9, 0x5f, 0x03, 0xf8, 0x36, 0x95, 0xcb, 0x38, 0xb1, 0x3e, 0x40, 0x0f,
385: };
386:
387: // SHA256
388: SHA256_CTX *context = SHA256_CreateAlgorithm();
389:
390: // 一気にハッシュ
391: {for( int i = 1; (i * SHA256_HASHSIZE) < numof( testcase ); ++i )
392: {
393: SHA256_InitData( context );
394: SHA256_AddData( context, testcase, i * SHA256_HASHSIZE );
395:
396: BYTE sha[ SHA256_HASHSIZE ];
397: {for( int j = 1; j < numof( sha ); ++j )
398: {
399: SHA256_GetHash( context, sha, j );
400: VERIFY( 0 == memcmp( sha, testcase + (i * SHA256_HASHSIZE), j ) );
401: }}
402: }}
403:
404: // 徐々にハッシュ
405: SHA256_InitData( context );
406: {for( int i = 1; (i * SHA256_HASHSIZE) < numof( testcase ); ++i )
407: {
408: {for( int j = 0; j < SHA256_HASHSIZE; ++j )
409: {
410: SHA256_AddData( context, &testcase[ j + ((i-1) * SHA256_HASHSIZE) ], 1 );
411: }}
412:
413: BYTE sha[ SHA256_HASHSIZE ];
414: SHA256_GetHash( context, sha, numof( sha ) );
415: VERIFY( 0 == memcmp( sha, testcase + (i * SHA256_HASHSIZE), numof( sha ) ) );
416: }}
417:
418: VERIFY( SHA256_DestroyAlgorithm( context ) );
419:
420: }//test_sha256
421:
422:
423: #endif // #ifdef _DEBUG
424:
425:
426: //** end **
参照：
| 水無瀬の部屋 > sample > tools > misc > sha256.cpp |
|---|
このページは cpp2web が出力しました。
水無瀬 優 postmaster@katsura-kotonoha.sakura.ne.jp
http://katsura-kotonoha.sakura.ne.jp/prog/code/tools/misc/sha256_cpp.shtml